Java Technologies Observer Pattern এবং Generics গাইড ও নোট

Observer Pattern হল একটি আচরণগত নকশা (Behavioral Design Pattern), যা অবজেক্টের মধ্যে one-to-many সম্পর্ক প্রতিষ্ঠা করে। কোনো অবজেক্টের স্টেট পরিবর্তিত হলে সংশ্লিষ্ট অবজেক্টগুলোকে স্বয়ংক্রিয়ভাবে অবহিত করার জন্য এটি ব্যবহৃত হয়।

Generics ব্যবহার করে Observer Pattern আরও Type-Safe, Flexible, এবং Reusable করা যায়।

Observer Pattern এর গঠন:

1. Subject (Observable): স্টেট ট্র্যাক করে এবং পর্যবেক্ষকদের (Observers) নোটিফাই করে।
2. Observer: স্টেট পরিবর্তনের প্রতি সাড়া দেয়।

Generics সহ Observer Pattern এর উদাহরণ

1. Observer ইন্টারফেস

public interface Observer<T> {
    void update(T data);
}

2. Subject ইন্টারফেস

import java.util.ArrayList;
import java.util.List;

public class Subject<T> {
    private List<Observer<T>> observers = new ArrayList<>();

    public void addObserver(Observer<T> observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer<T> observer) {
        observers.remove(observer);
    }

    public void notifyObservers(T data) {
        for (Observer<T> observer : observers) {
            observer.update(data);
        }
    }
}

Generics সহ Observer Pattern ব্যবহার

স্টেপ ১: বাস্তবায়ন

public class ConcreteObserver implements Observer<String> {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public void update(String data) {
        System.out.println(name + " received update: " + data);
    }
}

স্টেপ ২: ব্যবহার

public class Main {
    public static void main(String[] args) {
        Subject<String> subject = new Subject<>();

        Observer<String> observer1 = new ConcreteObserver("Observer 1");
        Observer<String> observer2 = new ConcreteObserver("Observer 2");

        subject.addObserver(observer1);
        subject.addObserver(observer2);

        subject.notifyObservers("Hello, Observers!");
    }
}

আউটপুট:

Observer 1 received update: Hello, Observers!
Observer 2 received update: Hello, Observers!

Generics ব্যবহার করার সুবিধা

1. Type-Safety: টাইপ কাস্টিংয়ের প্রয়োজন নেই।
2. Reusability: বিভিন্ন টাইপের জন্য একই Observer Pattern পুনঃব্যবহার করা যায়।
3. Flexibility: একই Subject বিভিন্ন ধরনের Observers পরিচালনা করতে পারে।

Advanced Example: Multiple Observers with Different Data Types

Multi-Type Observer

public class MultiTypeObserver<T> implements Observer<T> {
    private String name;

    public MultiTypeObserver(String name) {
        this.name = name;
    }

    @Override
    public void update(T data) {
        System.out.println(name + " received: " + data);
    }
}

Multi-Type Subject ব্যবহার

public class Main {
    public static void main(String[] args) {
        Subject<Integer> intSubject = new Subject<>();
        Subject<String> stringSubject = new Subject<>();

        Observer<Integer> intObserver = new MultiTypeObserver<>("Integer Observer");
        Observer<String> stringObserver = new MultiTypeObserver<>("String Observer");

        intSubject.addObserver(intObserver);
        stringSubject.addObserver(stringObserver);

        intSubject.notifyObservers(100);
        stringSubject.notifyObservers("Generics in Observer Pattern");
    }
}

আউটপুট:

Integer Observer received: 100
String Observer received: Generics in Observer Pattern

Real-World Application: Stock Price Monitoring

Observer: Stock Price Listener

public class StockPriceObserver implements Observer<Double> {
    private String investorName;

    public StockPriceObserver(String investorName) {
        this.investorName = investorName;
    }

    @Override
    public void update(Double price) {
        System.out.println(investorName + " notified: Stock price updated to $" + price);
    }
}

Subject: Stock Price Tracker

public class StockPriceTracker extends Subject<Double> {
    private double price;

    public void setPrice(double price) {
        this.price = price;
        notifyObservers(price);
    }
}

Main Program

public class Main {
    public static void main(String[] args) {
        StockPriceTracker tracker = new StockPriceTracker();

        Observer<Double> investor1 = new StockPriceObserver("Investor 1");
        Observer<Double> investor2 = new StockPriceObserver("Investor 2");

        tracker.addObserver(investor1);
        tracker.addObserver(investor2);

        tracker.setPrice(150.50);
        tracker.setPrice(160.75);
    }
}

আউটপুট:

Investor 1 notified: Stock price updated to $150.5
Investor 2 notified: Stock price updated to $150.5
Investor 1 notified: Stock price updated to $160.75
Investor 2 notified: Stock price updated to $160.75

Generics এবং Observer Pattern একত্রে ব্যবহার করলে:

1. টাইপ-সেফ এবং পুনঃব্যবহারযোগ্য কোড তৈরি হয়।
2. বিভিন্ন ডেটা টাইপের Observers এবং Subjects সহজেই পরিচালনা করা যায়।
3. বাস্তব জীবনের সমস্যাগুলোর (যেমন Stock Price Monitoring) জন্য উন্নত এবং কার্যকর সমাধান প্রদান করা যায়।